/**
* @author TDSoft
*
* La clase RemotoImplementacion proporciona la implementaciÓn
*   de la interface RemoteInterface y desarrollo el acceso remoto
*   a algunos m�todos
*
* @see RemotoInterface
*/

package edu.uoc.tds.pec4.server.impl;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.io.Serializable;
import java.util.*;

import edu.uoc.tds.pec4.model.Usuario;
import edu.uoc.tds.pec4.model.Universidad;
import edu.uoc.tds.pec4.common.RemotoInterface;
import edu.uoc.tds.pec4.model.Administrador;
import edu.uoc.tds.pec4.model.Estudiante;
import edu.uoc.tds.pec4.model.Inscripcion;
import edu.uoc.tds.pec4.model.Medallero;
import edu.uoc.tds.pec4.model.ParticipantesEstadistica;
import edu.uoc.tds.pec4.model.Pregunta;
import edu.uoc.tds.pec4.model.Prueba;
import edu.uoc.tds.pec4.model.PruebaDetalleEstadistico;
import edu.uoc.tds.pec4.model.ResponsablePrueba;
import edu.uoc.tds.pec4.model.ResultadoEstudiante;
import edu.uoc.tds.pec4.model.Ronda;
import edu.uoc.tds.pec4.model.TipoEstado;
import edu.uoc.tds.pec4.model.TipoRonda;
import edu.uoc.tds.pec4.server.bbdd.GestorAdministrador;
import edu.uoc.tds.pec4.server.bbdd.GestorBBDD;
import edu.uoc.tds.pec4.server.bbdd.GestorEstadistica;
import edu.uoc.tds.pec4.server.bbdd.GestorEstudiante;
import edu.uoc.tds.pec4.server.bbdd.GestorInscripcion;
import edu.uoc.tds.pec4.server.bbdd.GestorInscripcionRonda;
import edu.uoc.tds.pec4.server.bbdd.GestorPregunta;
import edu.uoc.tds.pec4.server.bbdd.GestorPrueba;
import edu.uoc.tds.pec4.server.bbdd.GestorResponsablePrueba;
import edu.uoc.tds.pec4.server.bbdd.GestorRonda;
import edu.uoc.tds.pec4.server.bbdd.GestorUsuario;
import edu.uoc.tds.pec4.server.bbdd.GestorUniversidad;
import java.sql.Connection;

public class RemotoImplementacion extends UnicastRemoteObject
    implements RemotoInterface, Serializable {

    private static final long serialVersionUID = 10000000L;
    
    //Se usa para la gestión de la conexión y desconexión de la base de datos
    //y para la gestión de las sentencias necesarias para los accesos a la misma.
    private GestorBBDD gestorBBDD;
    //Conexión a la BBDD.
    private Connection conexion;
    //Schema de BBDD
    private String schema;

    public RemotoImplementacion() throws RemoteException {
        super();
    }

    //*******
    //CLIENTE
    //*******
    
    //Método que realiza la conexión a la BBDD
    public boolean conectaBBDD() throws RemoteException {
        boolean conexionRealizada = false;
        this.gestorBBDD = new GestorBBDD();
        
        if (!this.gestorBBDD.isConectado()){
            //Si no existe ya conexión intentamos conectarnos
            if (gestorBBDD.conectaBBDD()) {
                //Si la conexión se ha realizado correctamente
                this.conexion = this.gestorBBDD.getConexion();
                this.schema = this.gestorBBDD.getSchema();
                //Si se ha realizado correctamente la conexión
                conexionRealizada = true;
            }
        }else{
            //Si ya existe conexión
            conexionRealizada = true;
        }
        return conexionRealizada;
    }
    
    //Obtiene el schema que se ha recuperado del fichero de configuración para usarlo en las sentecias
    public String getSchema() throws RemoteException{
        return this.schema;
    }

    //Método que realiza la desconexión de la BBDD
    public void desconectaBBDD() throws RemoteException {
        //Desconecta cuando existe una conexión
        gestorBBDD.desconectaBBDD();
    }

    //Obtiene la conexión que hemos establecido
    public Connection getConexion() throws RemoteException{
        return this.gestorBBDD.getConexion();
    }

    //********
    //USUARIOS
    //********
    
    //Metodo para validar un Usuario a partir de su login y clave introducidos.
    public Usuario validarUsuario(String login, String clave) throws RemoteException {
        GestorUsuario gestorUsuario = new GestorUsuario(this);
        return gestorUsuario.validarUsuario(login, clave);
    }

    //Obtiene un usuario, a partir de un id_usuario
    public Usuario getUsuario(int id_usuario) throws RemoteException{
        Usuario usuario = null;
        GestorUsuario gestorUsuario = new GestorUsuario(this);
        usuario = gestorUsuario.getUsuario(id_usuario);

        return usuario;
    }
    
    //Devuelve una instancia de Universidad correspondiente a un valor de id_universidad.
    public Universidad getUniversidad(int id_universidad) throws RemoteException {
        GestorUniversidad gestorUniversidad = new GestorUniversidad(this);
        return gestorUniversidad.getUniversidad(id_universidad);
    }

    //Devuelve el identificador de la universidad a partir de su nombre.
    public int getIdUniversidad(String nombre_universidad) throws RemoteException{
        GestorUniversidad gestorUniversidad = new GestorUniversidad(this);
        return gestorUniversidad.getIdUniversidad(nombre_universidad);
    }
    
    //Obtiene la lista de todas la universidades disponibles en el sistema.
    public List<Universidad> getUniversidades() throws RemoteException{
        GestorUniversidad gestorUniversidad = new GestorUniversidad(this);
        return gestorUniversidad.getUniversidades();
    }
    
    //Devuelve true si el objeto usuario hacer referencia a una instancia de clase Estudiante.
    //Devuelve false en caso contrario.
    public boolean isEstudiante(Usuario usuario) throws RemoteException{
        GestorEstudiante gestorEstudiante = new GestorEstudiante(this);
        return gestorEstudiante.isEstudiante(usuario);
    }
    
    //Devuelve true si el objeto usuario hacer referencia a una instancia de clase Administrador.
    //Devuelve false en caso contrario.
    public boolean isAdministrador(Usuario usuario) throws RemoteException{
        GestorAdministrador gestorAdministrador = new GestorAdministrador(this);
        return gestorAdministrador.isAdministrador(usuario);
    }
    
    //Devuelve true si el objeto usuario hacer referencia a una instancia de clase ResponsablePrueba.
    //Devuelve false en caso contrario.
    public boolean isResponsablePrueba(Usuario usuario) throws RemoteException{
        GestorResponsablePrueba gestorResponsablePrueba = new GestorResponsablePrueba(this);
        return gestorResponsablePrueba.isResponsablePrueba(usuario);
    }
    
    //Obtiene la instancia Estudiante a la que hace referencia el objeto usuario.
    public Estudiante getEstudiante(Usuario usuario) throws RemoteException{
        GestorEstudiante gestorEstudiante = new GestorEstudiante(this);
        return gestorEstudiante.getEstudiante(usuario);
    }
    
    //Obtiene la instancia Administrador a la que hace referencia el objeto usuario.
    public Administrador getAdministrador(Usuario usuario) throws RemoteException{
        GestorAdministrador gestorAdministrador = new GestorAdministrador(this);
        return gestorAdministrador.getAdministrador(usuario);
    }
    
    //Obtiene la instancia ResponsablePrueba a la que hace referencia el objeto usuario.
    public ResponsablePrueba getResponsablePrueba(Usuario usuario) throws RemoteException{
        GestorResponsablePrueba gestorResponsablePrueba = new GestorResponsablePrueba(this);
        return gestorResponsablePrueba.getResponsablePrueba(usuario);
    }

    //Realiza el alta de un usuario, a partir de los datos introducidos por el Administrador y que 
    //se pasan como parámetros.
    public Usuario altaUsuario(int id_tipo_usuario, String login, String clave, String documento,
                                String nombre, String apellidoPrimero, String apellidoSegundo, 
                                int id_universidad, Date fecha_alta) throws RemoteException{
        GestorUsuario gestorUsuario = new  GestorUsuario(this);
        return gestorUsuario.altaUsuario(id_tipo_usuario, login, clave, documento,
                                nombre, apellidoPrimero, apellidoSegundo, id_universidad, fecha_alta);
    }
    
    //Realiza la baja lógica de un usuario. Se pasan por parámetro el identificador del usuario
    //y la fecha de la baja.
    public void bajaUsuario(int id_usuario, Date fecha_baja) throws RemoteException{
        GestorUsuario gestorUsuario = new  GestorUsuario(this);
        gestorUsuario.bajaUsuario(id_usuario, fecha_baja);
    }
    
    //Obtiene la lista de usuarios a partir de los filtros pasados por parámetro.
    public List<Usuario> getListaUsuarios(int id_tipo_usuario,int id_usuario, String documento, 
                                          String nombre, String apellido_primero, Date fecha_alta,
                                          String operador_fecha_alta, boolean activos,
                                          Date fecha_baja, String operador_fecha_baja,
                                          int id_universidad) throws RemoteException{
        GestorUsuario gestorUsuario = new  GestorUsuario(this);
        return gestorUsuario.getListaUsuarios(id_tipo_usuario,id_usuario, documento, 
                                          nombre, apellido_primero, fecha_alta,
                                          operador_fecha_alta, activos,
                                          fecha_baja, operador_fecha_baja,
                                          id_universidad);
    }
    
    //Obtiene la lista de pruebas pendientes que tiene un Estudiante.
    public List<Prueba> getListaPruebasEstudiante(int id_usuario) throws RemoteException{
        GestorPrueba gestorPrueba = new  GestorPrueba(this);
        return gestorPrueba.getListaPruebasEstudiante(id_usuario);
    }
    
    
    //Comprueba si el login introducido por el Administrador en el caso de uso de Alta de usuarios, ya existe en el sistema.
    public boolean existeLogin(String login_usuario) throws RemoteException{
        GestorUsuario gestorUsuario = new  GestorUsuario(this);
        return gestorUsuario.existeLogin(login_usuario);
    }
    
    //Comprueba si el documento introducido por el Administrador en el caso de uso de Alta de usuarios, ya existe en el sistema.
    public boolean existeDocumento(String documento) throws RemoteException{
        GestorUsuario gestorUsuario = new  GestorUsuario(this);
        return gestorUsuario.existeDocumento(documento);
    }
    
    //********
    //PRUEBAS
    //********
    
    //<<FTM
    //Método que devuelve una instancia de Prueba a partir de un id de prueba
    public Prueba getPrueba(int id_prueba) throws RemoteException{
        Prueba prueba = null;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        prueba = gestorPrueba.getPrueba(id_prueba);

        return prueba;
    }

    //Método que devuelve una lista de instancias de Prueba
    public List<Prueba> getListaPruebas() throws RemoteException{
        List<Prueba> lista = null;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        lista = gestorPrueba.getListaPruebas();

        return lista;
    }

    //Método que devuelve una lista de instancias de Prueba a partir de una Prueba pasada por parametro
    public List<Prueba> getListaPruebas(Prueba prueba) throws RemoteException{
        List<Prueba> lista = null;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        lista = gestorPrueba.getListaPruebas(prueba);

        return lista;
    }

    //Método que ddevuelve una lista de Pruebas en un estado pasado pasado or parametro
    public List<Prueba> getListaPruebasPorEstado(TipoEstado tipoEstado) throws RemoteException{
        List<Prueba> lista = null;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        lista = gestorPrueba.getListaPruebasPorEstado(tipoEstado);

        return lista;
    }
    
    //Método que devuelve un booleano que indica si una prueba esta validad en fechas, coherencia,...
    //  laprueba se pasa por parametro
    public boolean validarPrueba(Prueba prueba) throws RemoteException{
        boolean esValido = false;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        esValido = gestorPrueba.validarPrueba(prueba);

        return esValido;
    }

    //Metodo que devuelve un entero correspondiente al id de prueba que se inserta en la tabla
    //   y que la función recibe por parametro
    public int insertarPrueba(Prueba prueba) throws RemoteException{
        int registroInsertado = 0;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        registroInsertado = gestorPrueba.insertarPrueba(prueba);

        return registroInsertado;
    }

    //Metodo que marca una prueba como anulada
    public void anularPrueba(int id_pruebla) throws RemoteException{
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        gestorPrueba.anularPrueba(id_pruebla);
    }

    //Metodo que actuliza una prueba en la BBDD a partir de su instancia y del estado
    public void actualizarPrueba(Prueba prueba, TipoEstado tipoEstado) throws RemoteException{
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        gestorPrueba.actualizarPrueba(prueba, tipoEstado);
    }

    //Metodo que devuelve una Fecha de Inicio de Inscripcion de una instancia de Prueba que se pasa por parametro
    public Date getFechaInicioInscripcionPrueba(Prueba prueba) throws RemoteException{
        Date fechaInicioInscripcionPrueba = null;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        gestorPrueba.getFechaInicioInscripcionPrueba(prueba);

        return fechaInicioInscripcionPrueba;
    }

    //Metodo que devuelve una Fecha de Fin de Inscripcion de una instancia de Prueba que se pasa por parametro
    public Date getFechaFinInscripcionPrueba(Prueba prueba) throws RemoteException{
        Date fechaFinInscripcionPrueba = null;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        fechaFinInscripcionPrueba = gestorPrueba.getFechaInicioInscripcionPrueba(prueba);

        return fechaFinInscripcionPrueba;
    }

    //Metodo que devuelve una cadena con la descripción de una instancia de Prueba que se pasa por parametro
    public String getDescripcionPrueba(Prueba prueba) throws RemoteException{
        String descripcionPrueba = null;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        descripcionPrueba = gestorPrueba.getDescripcionPrueba(prueba);

        return descripcionPrueba;
    }

    //Metodo que devuelve una cadena con la descripcion del estado de una prueba
    public String getDescripcionEstadoPrueba(int id_estado_prueba) throws RemoteException{
        String descripcionEstadoPrueba = null;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        descripcionEstadoPrueba = gestorPrueba.getDescripcionEstadoPrueba(id_estado_prueba);

        return descripcionEstadoPrueba;
    }

    //Metodo que devuelve un booleano que indica si hay un ronda en estado de clasificacion
    public boolean hayRondaClasificatoria(int numeroInscritos) throws RemoteException{
        boolean hayRondaClasificatoria = true;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        hayRondaClasificatoria = gestorPrueba.hayRondaClasificatoria(numeroInscritos);

        return hayRondaClasificatoria;
    }

    //Metodo que devuelve un booleano que indica si hay un ronda en estado eliminatorio
    public boolean hayRondaEliminatoria(int numeroInscritos) throws RemoteException{
        boolean hayRondaEliminatoria = true;
        GestorPrueba gestorPrueba = new GestorPrueba(this);
        hayRondaEliminatoria = gestorPrueba.hayRondaEliminatoria(numeroInscritos);

        return hayRondaEliminatoria;
    }

    //Metodoque devuelve una cadenacon las respuestas de la ronda
    public String getRespuestasSolucion(Prueba prueba, TipoRonda tipoRonda) throws RemoteException{
        String respuestasSolucion = null;
        GestorRonda gestorRonda = new GestorRonda(this);
        respuestasSolucion = gestorRonda.getRespuestasSolucion(prueba, tipoRonda);
        
        return respuestasSolucion;
    }

    //Fernando
    //Metodo para valorr, para obtener la puntuacion, de un usuario en una ronda
    public void valorarParticipacionEnRonda(Prueba prueba, TipoEstado tipoEstado) throws RemoteException{
        GestorInscripcionRonda gestorInscripcionRonda = new GestorInscripcionRonda(this);
        gestorInscripcionRonda.valorarParticipacionEnRonda(prueba, tipoEstado);
    }

    //--GestorInscripcion
    //Fernando
    //Metodo para obtener el numero de inscritos en una prueba
    public int getNumeroInscritos(int id_prueba) throws RemoteException{
        int numero_inscritos;
        GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
        numero_inscritos = gestorInscripcion.getNumeroInscritos(id_prueba);

        return numero_inscritos;
    }

    //Fernando
    //Metodo que devuelve un booleano que indica se hay un numero de inscritos suficientes
    public boolean hayInscritosSuficientes(int numeroInscritos) throws RemoteException{
        boolean hayInscritosSuficientes = false;
        GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
        hayInscritosSuficientes = gestorInscripcion.hayInscritosSuficientes(numeroInscritos);

        return hayInscritosSuficientes;
    }

    //Fernando
    //Metodo para obtener una lista de estudiantes inscritos en una prueba
    public List<Usuario> getListaEstudiantesInscritosEnPrueba(Prueba prueba) throws RemoteException{
        List<Usuario> lista = new ArrayList<Usuario>();
        GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
        lista = gestorInscripcion.getListaEstudiantesInscritosEnPrueba(prueba);

        return lista;
    }

    //Metodo para obtener una lista con
    public List<Inscripcion> getListaInscritosEnPrueba(Prueba prueba) throws RemoteException
    {
        GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
        return gestorInscripcion.getListaInscritosEnPrueba(prueba);
    }

    public boolean realizarBajaInscripcionPrueba(Estudiante estudiante, Prueba prueba) throws RemoteException
    {
        GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
        return gestorInscripcion.realizarBajaInscripcionPrueba(estudiante, prueba);
    }

    public boolean realizarAltaInscripcionPrueba(Estudiante estudiante, Prueba prueba) throws RemoteException
    {
        GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
        return gestorInscripcion.realizarAltaInscripcionPrueba(estudiante, prueba);
    }

    public void realizarInscripcionUsuarios(Usuario usuario, Ronda ronda) throws RemoteException
    {
        GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
        gestorInscripcion.realizarInscripcionUsuarios(usuario, ronda);
    }

    public boolean guardarRespuestasUsuarios(Usuario usuario, Ronda ronda, String respuestas) throws RemoteException
    {
        GestorInscripcionRonda gestorInscripcionRonda = new GestorInscripcionRonda(this);
        return gestorInscripcionRonda.guardarRespuestasUsuarios(usuario, ronda, respuestas);
    }

    //Fernando
    //Metodo para insertar una Ronda cuya instancia se pasa por parametro
    public void insertarRonda(Ronda ronda) throws RemoteException{
        GestorRonda gestorRonda = new GestorRonda(this);
        gestorRonda.insertarRonda(ronda);
    }

    //Fernando
    //Metodo para cerrar una Ronda indicando el usuario que la cierra, pasando por parametro
    //  una prueba, un tipoRonda y una Prueba
    public void cerrarRonda(Prueba prueba, TipoRonda tipoRonda, Usuario usuario) throws RemoteException{
        GestorRonda gestorRonda = new GestorRonda(this);
        gestorRonda.cerrarRonda(prueba, tipoRonda, usuario);
    }

    //Fernando
    //Metodo que devuelve un booleano indicando si existe una Ronda cuya Prueba y Tipo se pasan por parametro
    public boolean existeRonda(Prueba prueba, TipoRonda tipoRonda) throws RemoteException{
        boolean existeRonda = false;
        GestorRonda gestorRonda = new GestorRonda(this);
        existeRonda = gestorRonda.existeRonda(prueba, tipoRonda);

        return existeRonda;
    }

    //Fernando
    //Metodo que devuelve un booleano que indica sis existe una ronda que se pasa por parametro
    public boolean existeRonda(Ronda ronda) throws RemoteException{
        boolean existeRonda = false;
        GestorRonda gestorRonda = new GestorRonda(this);
        existeRonda = gestorRonda.existeRonda(ronda);

        return existeRonda;
    }

    //Fernando
    //Metodo que devuelve una instancia de Ronda a partir de una instancia de Prueba y un TIpo de Ronda que se pasan por parametro
    public Ronda getRonda(Prueba prueba, TipoRonda tipoRonda) throws RemoteException{
        Ronda ronda = new Ronda();
        GestorRonda gestorRonda = new GestorRonda(this);
        ronda = gestorRonda.getRonda(prueba, tipoRonda);

        return ronda;
    }

    //Fernando
    //Metodo que devuelve un booleano que indica si se ha validado una Ronda que se pasa por parametro
    public boolean validarRonda(Ronda ronda) throws RemoteException{
        boolean esValido = false;
        GestorRonda gestorRonda = new GestorRonda(this);
        esValido = gestorRonda.ValidarRonda(ronda);

        return esValido;
    }

    //Fernando
    //Metodo para devovler una Lista de Rondas
    public List<Ronda> getListaRondas() throws RemoteException{
        List<Ronda> lista = new ArrayList<Ronda>();
        GestorRonda gestorRonda = new GestorRonda(this);
        lista = gestorRonda.getListaRondas();

        return lista;
    }

    public List<Ronda> getListaRondasEnRealizacion() throws RemoteException{
        GestorRonda gestorRonda = new GestorRonda(this);
        return gestorRonda.getListaRondasEnRealizacion();
    }

    //Fernando
    //Metodo para actualizar una Ronda que se pasa por parametro
    public void actualizarRonda(Ronda ronda) throws RemoteException{
        GestorRonda gestorRonda = new GestorRonda(this);
        gestorRonda.actualizarRonda(ronda);
    }

    //Fernado
    //Metodo que devuelve una fecha que indica la fecha de realizacion de una Ronda
    //  que recibe por parametro, la prueba y el tipo de ronda
    public Date getFechaInicioRealizacionRonda(Prueba prueba, TipoRonda tipoRonda) throws RemoteException{
        Date fechaInicioRealizacionRonda = null;
        GestorRonda gestorRonda = new GestorRonda(this);
        fechaInicioRealizacionRonda = gestorRonda.getFechaInicioRealizacionRonda(prueba, tipoRonda);

        return fechaInicioRealizacionRonda;
    }

    //Fernando
    //Metodo que devuelve una lista de Usuarios inscritos en una Ronda que se pasa por parametro
    public List<Usuario> getListaEstudiantesInscritosEnRonda(Ronda ronda) throws RemoteException{
        List<Usuario> lista = new ArrayList<Usuario>();
        GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
        lista = gestorInscripcion.getListaEstudiantesInscritosEnRonda(ronda);

        return lista;
    }

    //Fernando
    //Metodo que devuelve una lista del TOP de usuarios, en puntuacion de una Ronda
    public List<Usuario> getListaTOPEstudiantesInscritosEnRonda(Ronda ronda) throws RemoteException{
        List<Usuario> lista = new ArrayList<Usuario>();
        GestorInscripcionRonda gestorInscripcionRonda = new GestorInscripcionRonda(this);
        lista = gestorInscripcionRonda.getListaTOPEstudiantesInscritosEnRonda(ronda);
        
        return lista;
    }

    public boolean haRealizadoRonda(Estudiante estudiante, Ronda ronda) throws RemoteException{
        GestorInscripcionRonda gestorInscripcionRonda = new GestorInscripcionRonda(this);
        return gestorInscripcionRonda.haRealizadoRonda(estudiante, ronda);
    }

    public String getDescripcionTipoRonda(int id_tipo_ronda) throws RemoteException{
        String descripcionRonda = null;
        GestorRonda gestorRonda = new GestorRonda(this);
        descripcionRonda = gestorRonda.getDescripcionTipoRonda(id_tipo_ronda);

        return descripcionRonda;
    }

    public String getRespuestasEstudiantes(Ronda ronda, Usuario usuario) throws RemoteException{
        String respuestasEstudiantes = null;
        GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
        respuestasEstudiantes = gestorInscripcion.getRespuestasEstudiantes(ronda, usuario);

        return respuestasEstudiantes;
    }

    public boolean estaInscritoEnPrueba(Estudiante estudiante, Prueba prueba) throws RemoteException{
         GestorInscripcion gestorInscripcion = new GestorInscripcion(this);
         return gestorInscripcion.estaInscritoEnPrueba(estudiante, prueba);
    }

    //Fernando
    //Metodo para realizar la ordenacion de la puntuacion de los inscritos en una ronda considerancdo
    //   la puntuacion y la fecha de realiacion de la prueba
    public void ordenarInscripcionRondaPorPuntuacionYFecha(Prueba prueba, TipoRonda tipoRonda) throws RemoteException{
        GestorInscripcionRonda gestorInscripcionRonda = new GestorInscripcionRonda(this);
        gestorInscripcionRonda.ordenarInscripcionRondaPorPuntuacionYFecha(prueba, tipoRonda);
    }

    //Fernando
    //Metodo qye devuelve un número de preguntas determinado por el parámetro que recibe
    public List<Pregunta> getListaPreguntas(int numeroPreguntas) throws RemoteException{
        List<Pregunta> listaPreguntas = new ArrayList<Pregunta>();
        GestorPregunta gestorPregunta = new GestorPregunta(this);
        listaPreguntas = gestorPregunta.getListaPreguntas(numeroPreguntas);

        return listaPreguntas;
    }
    //>>

    public Pregunta getPregunta(int id_pregunta) throws RemoteException
    {
        GestorPregunta gestorPregunta = new GestorPregunta(this);
        return gestorPregunta.getPregunta(id_pregunta);
    }

    public int numPrueba() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.numPruebas();         
    }
   
   public int pruebasEnCurso() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.pruebasEnCurso();
   }
   
   public int pruebasFinalizadas() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.pruebasFinalizadas();
   }
   
   public int estudiantesInscritos() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.estudiantesInscritos();
   }
   
   public int universidadesParticipantes() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.universidadesParticipantes();
   }
   
   public int medallas() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.medallas();
   }
   
   public int pruebasInscripcion() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.pruebasInscripcion();
   }
   
   public int inscritosPruebasConCierre() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.inscritosPruebasConCierre();
   }
      
   public String participantesDeInscritos() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.participantesDeInscritos();
   }

   public double puntuacionMedia() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.puntuacionMedia();
   }
 
   public double preguntasMedias() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.preguntasMedias();
   }           

   public String aciertosPreguntas() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.aciertosPreguntas();
   } 
   public List<ResultadoEstudiante> obtenerResultadosEstudiante(Estudiante estudiante) throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.obtenerResultadosEstudiante(estudiante);
   }
    public List<PruebaDetalleEstadistico> obtenerPruebaDetalleEstadistico() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.obtenerPruebaDetalleEstadistico();
   }
    
    public List<ParticipantesEstadistica> obtenerParticipantes(int iP, int iTP, String fD, String fH) throws RemoteException{
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.obtenerParticipantes(iP, iTP, fD, fH);
    }

    public List<Medallero> obtenerMedallero() throws RemoteException {
        GestorEstadistica gestorEstadistica = new GestorEstadistica(this);
        return gestorEstadistica.obtenerMedallero();
    }
}
